Práctica 06: Perceptron de una capa
Integrantes:
- Palma Mejía Luis Adrián
- Fabián Carrasco Yahadad
- Flores Vázquez Elvin
- Tenorio Camacho Javier
Contenido
Objetivos
- Implementar la regla de aprendizaje perceptrón par entradas en
- Implementar visulización en
y 
Introducción
El articulo aborda la manera en la que el modelo del preceptron es un modelo que se asemeja a o podria plantearse como una alternativa al entendimiento de como el cerebro procesa la información.
Se comienza plantenando tres preguntas fundamentales que como seres humanos realizamos dia a dia aun que raramente nos detenemos a reflexionar el como suceden, y es relacionado a la manera en la que procesamos la información, partiendo de ¿como son detectados los estimulos que nos proven cierta información?, ¿Como es esta información almacenda? y por ultimo, ¿como esta información influye en nuestr comportameinto o en la manera en la que reconocemos las cosas?.
Principalmente centrandose en las ultimas dos preguntas, y partiendo por la primera de estas dos. Se plantea que el cerebro almacena información en forma de codigos o imagenes en un modo de clasificación de el estimulo recibido con un patronalmacenado o aprendido. Por otro lado tambien se plantea que en realidad el cerebro no realiza un almacenamiento como tal, sino que en el sistema nervioso central (SNC), se crean nuevas rutas hacia ciertas zonas del cerebro con lo que los estimulos entrantesseria mas equiparados a una idea que una acción concreta. De otro modo se puede decir que la primer idea cataloga un estimulo con cierto patron , y la segunda asocia ciertas caracteristicas de dicho estimulo creando una asociaciones de elementos de dicho estumulo sin catalogarlo perse.
Teniendo en cuenta estas dos hipotessis de "almacenamiento" de la información la respuesta a la tecer pregunta, para la primera hipotesis se basa en que al compararse de manera sistematica los estimulos entrantes con los ya clasificados, de la misma manera se determina el comportamiento a los estimulos dentro de las mimmas "clases" de almacenamiento mientras que de acuerdo a la segunda hipotesis, los estimulos entrantes seguiran los mismos caminos (o al menos caminos parecidos) a los que correspondientes a estimulos anteriores a estos.
Esta ultima teoria llamada "Coneccionista" seria la manera enla que el perceptron toma decisiones.
De esta manera conociendo la manera en la que trabaja el perceptron podriamos decir que cada vez que se entra una red de esta arquitectura y los pesos y desviaciones se ajustan, seria similar a la manera en la que un estimulo seguiria un mismo camino o uno parecido al de un estimilo similar que entro anteriormente mientras que estos mismos cominos serian los formados con cada entrenamiento, por lo que despues de muchas decadas de entrenamiento los estimulos asociados a ciertos patrones tendrian aociada de manera practicamente inmediata la respuesta a la que estan asociados estos tipos de estimulos.
Otro punto importante tambien a tomar en cuenta es que no todos los SNC son iguales por lo que su ruta de aprendizaje es distinta, esto en similitud en la manera en la que se incia elaprendizaje de un perceptron indicaria la manera en la que como todos estos sstemas apprende en algunas ocaciones mas o menos rapido.
Problemas
Problema 1
Elabore una función que entrene un perceptron de 1 capa y S neuronas. Para ello considere lo siguiente:
- La función recibe de argumentos el conjunto de entradas P de dimensión R, y los objetivos correspondientes t de dimención n.
- La función recibe el numero de epocas de entrenamiento
- La función recibe como parametro opcional una tolerancia (numero real positivo, que se piensa pequeño) como un criterio de paro adicional.
- La función regresa los pesos y la desviación resultante, con un mensaje de exito o fracaso, indicando bajo que circunstancias se reportan los resultados.
El numeró de neuronas debe de elegirse de acuerdo a la dimensión t (¿por qué?)
Porque la cantidad de clases máximas que una arquitectura puede clasifica depende del número de neuronas, más específicamente
será el número máximo de clases que un perceptrón de S neuronas puede clasificar
Puede iniciaizar los parámetros con numeros aleatorios pequeños incluso pueden ser cero.
El programa debe deternerse de acuerdo a diferentes criterios:
- Se logro el entrenamiento antes del numero de epocas indicado, se indica que esto ocurre
- Se alcanzo el número de epocas ingresado, se debe indicar si con esta selección se logro o no el entrenamiento
- Se logro la tolerancia indicada (en caso de ser ingresada). Es decir, si
donde la resta es entre los parametros estimados en la epoca i e 
, con la norma usual (aunque algunos algortimos utilizan la norma infinito, puedes implementar esta en lugar de la norma 2, si así lo deseas). Se despliega un menaje para indicar que esto ocurrio
, con la norma usual (aunque algunos algortimos utilizan la norma infinito, puedes implementar esta en lugar de la norma 2, si así lo deseas). Se despliega un menaje para indicar que esto ocurriofunction [W,b] = perceptron1(entradas,objetivos,epocas,tolerancia)
if nargin<4
tolerancia = 1;
end
[r,numr] = size(entradas);
[n,numt] = size(objetivos);
% numero de clases
numClase = zeros(1,numt);
for tt=1:numt
cont = 0;
for exp=1:n
cont = (2^(exp-1))*objetivos(exp,tt) + cont;
end
numClase(tt) = cont;
end
numClases = length(unique(numClase));
% neuronas = ceil(log2(numClases));
syms n
eq = 1 + (n+1)*n/2 == numClases;
res = double(solve(eq,n));
sol = find(res >= 0);
neuronas = ceil(res(sol(1)));
disp('Existen '+string(numClases) +' clases, por lo que se necesitan '+ string(neuronas) + ' neuronas')
% fin numero de clases
% disp(neuronas)
% Generar los pesos y desviaciones
rng(0,'twister');
W = round((100-(-100)).*rand(r,neuronas) + (-100));
b = round((100-(-100)).*rand(neuronas,1) + (-100));
% size(W): columnas pesos(entradas), filas son neuronas
% W = numr x neuronas
% W = [0; 0];
% b = [0];
% W = [1 0;0 1];
% b = [1;1];
flag1 = true;
r = neuronas;
while epocas > 0 && flag1
W0 = W(:,end-r+1:end)';
% disp(W0)
b0 = b(:,end);
% disp(b0)
for it=1:numt
p = entradas(:,it);
% disp('p')
% disp(p)
t = objetivos(:,it);
% disp('t')
% disp(t)
a = hardlim(W0 * p + b0);
% disp('a')
% disp(a)
e = t - a;
% disp('e')
% disp(e)
W = horzcat(W,(W0 + e * p')');
b = horzcat(b,b0 + e);
W0 = W(:,end-r+1:end)';
b0 = b(:,end);
end
if sum((W(:,end-r+1:end) - W(:,end - numt*r+1:end - numt*r + r)).^2) < tolerancia % Norma 2
% if sum((W(:,end) - W(:,end - numt)).^2) < tolerancia % Norma 2
% if sum((abs(W(:,end)) - W(:,end - numt)).^2) < tolerancia % Norma Infinito
flag1 = false;
end
epocas = epocas - 1;
end
W0 = W(:,end)';
% disp('W0')
% disp(W0)
b0 = b(:,end);
% disp('b0')
% disp(b0)
tfinal = hardlim(W(:,end-r+1:end)'*entradas + b(:,end));
% disp('tfinal')
% disp(tfinal)
if epocas == 0
disp('Se alcanzo el numero de epocas')
else
disp('No se alcanzo el numero de epocas')
end
if all(tfinal == objetivos)
disp('La clasificacion es correcta')
else
disp('La clasificacion no es correcta')
end
if flag1 == true
disp('No se cumple la tolerancia de '+string(tolerancia))
else
disp('Se cumple la tolerancia de '+string(tolerancia))
end
% plot(C1(1,:),C1(2,:), 'bo', 'MarkerSize',20)
%
% plot(C2(1,:),C2(2,:), 'gs','MarkerSize',20)
% plot(C3(1,:),C3(2,:), 'ro', 'MarkerSize',30, 'LineWidth',5)
% plot(C4(1,:),C4(2,:), 'ks','MarkerSize',30,'LineWidth',5)
end
Problema 2
Elabore una función para clasificar vectores en con las siguientes características
con las siguientes características- La función recibe el numero de clases, las entradas y objetivos correspondientes
- El entrenamiento se lleva acabo mediante la regla de perceptrón (la suposición es que el problema es linealmente separable, por lo que el algoritmo tendrá que terminar de entrenarse), aquí puedes utilizar la función del problema 1, si asi lo deseas.
- La función despliega una gráfica donde se muestren elementos gráficos para indicar los vectores asociados a cada clase, los hiperplanos correspondientes de separación. los vectores ortogonales a cada plano y etiquetas de descripción (ejemplos clase)
- La función imprime los parametrós calculados, el número de epocas de entreanmiento con lo qeu esto se logro y las ecuaciones de los hiperplanos separadores.
- La función imprime en una misma figura el movimiento de los pesos en cada iteración de forma independiente. Por ejemplo, si se tienen 2 neuronas la figura tendrá que mostrar 4 graficas (la sucesión de cada peso, esto ilustra la convergencia). Para el bias se tendrá que contruir una segunda figura que muestre las sucesión de las desviaciones, en el ejemplo de dos neuronas, la figura tendría que tener la gráfica de dos sucesiones.
Proponga un problema de clasificación con 8 clases, que sea linealmente separable, donde cada clase tenga dos vectores asociados para el entrenamiento.
Para este problema se usan los siguientes puntos y objetivos, donde la función problema2 hace uso de la función perceptron1 con la diferencia que usa los datos de retorno para realizar las gráficas
p1 = [40;60];
t1 = [0;0;0;0];
p2 = [40;65];
t2 = t1;
p3 = [20;-40];
t3 = [1;0;0;0];
p4 = [25;-40];
t4 = t3;
p5 = [5;80];
t5 = [0;1;0;0];
p6 = [-5;65];
t6 = t5;
p7 = [-40;-30];
t7 = [1;1;0;0];
p8 = [-40;-20];
t8 = t7;
p9 = [-20;-60];
t9 = [0;0;1;0];
p10 = [-20;-75];
t10 = t9;
p11 = [-75;20];
t11 = [1;0;1;0];
p12 = [-85;20];
t12 = t11;
p13 = [60;30];
t13 = [0;1;1;0];
p14 = [70;30];
t14 = t13;
p15 = [-60;60];
t15 = [1;1;1;0];
p16 = [-60;75];
t16 = t15;
t = [t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16];
p = [p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12,p13,p14,p15,p16];
problema2(p,t,100);
El video donde se observa el funcionamiento del código implementado se puede descargar en el siguiente enlace o ver en el siguiente enlace.
Problema 3
Resuelva el problema 2 para clasificar vectores en .
.En el cápitulo 3 de Hagan hay un ejemplo de aplicación, páginas 3-1 a 3-6. Con esta idea, aplica la solución de ente probelma para clasificar naranjas y manzanas. Considera que los vectores de manzanas, están en el I octante, y los de naranjas en el III octante. Propon 2 entradas para cada clase.
clc, clear all
p1 = [4;1;1];
t1 = [1];
p2 = [1;4;1];
t2 = t1;
p3 = [-3;-4;2];
t3 = [0];
p4 = [-1;-1;2];
t4 = t3;
t = [t1,t2,t3,t4];
p = [p1,p2,p3,p4];
[W,b] = perceptron1(p,t,1000);
W0 = W(:,end)';
b0 = b(:,end);
syms p1l p2l p3l
eq = W0 * [p1l;p2l;p3l] + b0 == 0;
val = solve(eq,p3l)
[p1l,p2l] = meshgrid(-10:1:10);
p3l = double(subs(val));
figure
s = surf(p1l,p2l,p3l,'FaceAlpha',0.5)
s.EdgeColor = 'none';
hold on
plot3(p(1,:),p(2,:),p(3,:),'o')
r = 2;
neuronas = r;
for i=1:neuronas
for j=1:2
figure
plot(W(1,i:r:end),'o', 'MarkerSize',10)
title('convergencia del peso '+string(j)+ ' de la neurona '+ string(i) )
% axis([0 length(W(1,i:r:end)) min(W(1,i:r:end)) max(W(1,i:r:end))])
grid on
g = gca;
g.XAxisLocation = 'origin';
g.YAxisLocation = 'origin';
g.Box = 'off';
% [f,c]=size(W(1,i:r:end));
% text(W(1,i:r:end)+0.06*([0:c-1]),W(1,i:r:end)+0.1,string([0:c-1]))
end
end
% [fil,col] = size(W);
for i=1:neuronas
figure
plot(b(1,:),'o', 'MarkerSize',10)
title('convergencia del bias '+string(i))
% axis([0 length(W(1,i:r:end)) min(W(1,i:r:end)) max(W(1,i:r:end))])
grid on
g = gca;
g.XAxisLocation = 'origin';
g.YAxisLocation = 'origin';
g.Box = 'off';
% [f,c]=size(W(1,i:r:end));
% text(W(1,i:r:end)+0.06*([0:c-1]),W(1,i:r:end)+0.1,string([0:c-1]))
end
Problema 4
Se muestran los siguiente códigos en MATLAB
Clasificación, dos clases en
Creamos datos de entrenamiento de forma artificial
close all, clear all, clc, format compact
% numero de puntos para cada clase
N = 20;
% definición aritficial de entradas y salidas
offset = 5; % separación para las clases
x = [randn(2,N) randn(2,N)+offset]; % entradas
y = [zeros(1,N) ones(1,N)]; % salidas
% Gráfica de entradas con PLOTPV (gráfica vectores para perceptron entradas/salidas)
figure
plotpv(x,y)
Definición de la red y entrenamiento
net = perceptron(); % perceptron vacio
view(net) % esquema de topologia de red, tipo Hagan
net.trainParam.showWindow = 0; % no muestra el cuadro de dialogo del entrenamiento
net_trained = train(net,x,y); % entreanmos la red y guardamos la red entrenada
view(net_trained) % esquema de topologia de red entrenada, tipo Hagan
Gráfica de frontera de desición
hold on
plotpc(net_trained.IW{1},net_trained.b{1}); % función para impeme
Clasificación, cuatro clases en
close all, clear all, clc, format compact
% numero de muestras en cada clase
K = 2;
% definición de las clases
q = .6; % separación de la clases
A = [rand(1,K)-q; rand(1,K)+q];
B = [rand(1,K)+q; rand(1,K)+q];
C = [rand(1,K)+q; rand(1,K)-q];
D = [rand(1,K)-q; rand(1,K)-q];
figure(1); % no queremos repetir este codigo
figure(2); % creamso dos figura para copiar en contenido
figure(1) % activamos la figura 1
% graficamos clases
plot(A(1,:),A(2,:),'bs');
hold on
grid on
plot(B(1,:),B(2,:),'r+')
plot(C(1,:),C(2,:),'go')
plot(D(1,:),D(2,:),'m*')
% texto de las clases
text(.5-q,.5+2*q,'Clase A')
text(.5+q,.5+2*q,'Clase B')
text(.5+q,.5-2*q,'Clase C')
text(.5-q,.5-2*q,'Clase D')
% se definenen las salidas para las clases
a = [0 1]';
b = [1 1]';
c = [1 0]';
d = [0 0]';
% % ¿por qué estas salidas no funcionan?
% a = [0 0]';
% b = [1 1]';
% d = [0 1]';
% c = [1 0]';
% % ¿por qué estas salidas no funcionan?
% a = [0 1]';
% b = [1 1]';
% d = [1 0]';
% c = [0 1]';
CloneFig(1,2) % copiamos la figura 1 a la figura 2
Entradas y salidas
% definen las entradas (combinación para las cuatro clases)
P = [A B C D];
% definen las salidas
T = [repmat(a,1,length(A)) repmat(b,1,length(B)) ...
repmat(c,1,length(C)) repmat(d,1,length(D)) ];
%plotpv(P,T);
% aquí sería bueno imprimir P y T para menos estradas, para apreciar como
% se deben concatenar los valores
Se crea el perceptron y se entrena
net = perceptron;
net.trainParam.showWindow = 0;
net_trained = train(net,P,T);
view(net_trained)
Gráficamos la frontera de desición
figure(1) % activamos la figura 1
plotpc(net_trained.IW{1},net_trained.b{1});
Se entrega el desarrollo del ejemplo del problema 2 y el desarroolo del ejemplo de de problema 3 con las herramientas antes descritas.
Referencias
F. Rosenblatt, “The perceptron: A probabilistic model for information storage and organization in the brain,” Psycho- logical Review, Vol. 65, pp. 386–408, 1958.
Libro de Matin Hagan et. al. enlace
Implemenatción de perceptron con MATLAB, enlace
Función para clonar figuras enlace
Funciones utilizadas
function CloneFig(inFigNum,OutFigNum)
% this program copies a figure to another figure
% example: CloneFig(1,4) would copy Fig. 1 to Fig. 4
% Matt Fetterman, 2009
% pretty much taken from Matlab Technical solutions:
% http://www.mathworks.com/support/solutions/en/data/1-1UTBOL/?solution=1-1UTBOL
hf1=figure(inFigNum);
hf2=figure(OutFigNum);
clf;
compCopy(hf1,hf2);
function compCopy(op, np)
%COMPCOPY copies a figure object represented by "op" and its % descendants to another figure "np" preserving the same hierarchy.
ch = get(op, 'children');
if ~isempty(ch)
nh = copyobj(ch,np);
for k = 1:length(ch)
compCopy(ch(k),nh(k));
end
end
end
end
function [W,b] = perceptron1(entradas,objetivos,epocas,tolerancia)
if nargin<4
tolerancia = 1;
end
[r,numr] = size(entradas);
[n,numt] = size(objetivos);
% numero de clases
numClase = zeros(1,numt);
for tt=1:numt
cont = 0;
for exp=1:n
cont = (2^(exp-1))*objetivos(exp,tt) + cont;
end
numClase(tt) = cont;
end
numClases = length(unique(numClase));
% neuronas = ceil(log2(numClases));
syms n
eq = 1 + (n+1)*n/2 == numClases;
res = double(solve(eq,n));
sol = find(res >= 0);
neuronas = ceil(res(sol(1)));
disp('Existen '+string(numClases) +' clases, por lo que se necesitan '+ string(neuronas) + ' neuronas')
% fin numero de clases
% disp(neuronas)
% Generar los pesos y desviaciones
% rng(0,'twister');
W = round((100-(-100)).*rand(r,neuronas) + (-100));
b = round((100-(-100)).*rand(neuronas,1) + (-100));
% size(W): columnas pesos(entradas), filas son neuronas
% W = numr x neuronas
% W = [0; 0];
% b = [0];
% W = [1 0;0 1];
% b = [1;1];
flag1 = true;
r = neuronas;
while epocas > 0 && flag1
W0 = W(:,end-r+1:end)';
% disp(W0)
b0 = b(:,end);
% disp(b0)
for it=1:numt
p = entradas(:,it);
% disp('p')
% disp(p)
t = objetivos(:,it);
% disp('t')
% disp(t)
a = hardlim(W0 * p + b0);
% disp('a')
% disp(a)
e = t - a;
% disp('e')
% disp(e)
W = horzcat(W,(W0 + e * p')');
b = horzcat(b,b0 + e);
W0 = W(:,end-r+1:end)';
b0 = b(:,end);
end
if sum((W(:,end-r+1:end) - W(:,end - numt*r+1:end - numt*r + r)).^2) < tolerancia % Norma 2
% if sum((W(:,end) - W(:,end - numt)).^2) < tolerancia % Norma 2
% if sum((abs(W(:,end)) - W(:,end - numt)).^2) < tolerancia % Norma Infinito
flag1 = false;
end
epocas = epocas - 1;
end
W0 = W(:,end)';
% disp('W0')
% disp(W0)
b0 = b(:,end);
% disp('b0')
% disp(b0)
tfinal = hardlim(W(:,end-r+1:end)'*entradas + b(:,end));
% disp('tfinal')
% disp(tfinal)
if epocas == 0
disp('Se alcanzo el numero de epocas')
else
disp('No se alcanzo el numero de epocas')
end
if all(tfinal == objetivos)
disp('La clasificacion es correcta')
else
disp('La clasificacion no es correcta')
end
if flag1 == true
disp('No se cumple la tolerancia de '+string(tolerancia))
else
disp('Se cumple la tolerancia de '+string(tolerancia))
end
% plot(C1(1,:),C1(2,:), 'bo', 'MarkerSize',20)
%
% plot(C2(1,:),C2(2,:), 'gs','MarkerSize',20)
% plot(C3(1,:),C3(2,:), 'ro', 'MarkerSize',30, 'LineWidth',5)
% plot(C4(1,:),C4(2,:), 'ks','MarkerSize',30,'LineWidth',5)
end
function [] = problema2(p,t,epocas,tolerancia)
if nargin<4
tolerancia = 1;
end
[W,b] = perceptron1(p,t,epocas,tolerancia);
[n,numt] = size(t);
% numero de clases
numClase = zeros(1,numt);
for tt=1:numt
cont = 0;
for exp=1:n
cont = (2^(exp-1))*t(exp,tt) + cont;
end
numClase(tt) = cont;
end
marcadores = 'o+*.x_|sd^v<>ph'; %15 'o*.s';
colores = 'rbmk'; %7
numClases = length(unique(numClase));
unicos = unique(numClase);
% neuronas = ceil(log2(numClases));
syms n
eq = 1 + (n+1)*n/2 == numClases;
res = double(solve(eq,n));
sol = find(res >= 0);
neuronas = ceil(res(sol(1)));
r = neuronas;
disp('neuronas')
disp(neuronas)
W0 = W(:,end-r+1:end)';
b0 = b(:,end);
% cont = 0;
figure
for i=1:numClases
index = find(numClase == unicos(i));
% disp(index)
% disp(length(index))
% disp('Clase '+string(i))
% disp('longitud de '+string(length(index)))
% disp(index)
plot(p(1,index),p(2,index), string(marcadores(mod(i-1,15)+1)) + 'k', 'MarkerSize',10,'DisplayName','C'+string(i))
hold on
% for j=1:length(index)
% disp(p(:,index(j)))
% disp(marcadores(mod(i-1,15)+1))
% plot(p(1,index(j)),p(2,index(j)), string(marcadores(mod(i-1,15)+1)) + 'k', 'MarkerSize',20)
% hold on
% % disp(index(j))
% end
% disp(cont)
% cont = cont + 1;
end
legend('FontSize',5,'Location','bestoutside','NumColumns',1)
% legend("C1","C2","C3","C4",'FontSize',5,'Location','southwest')
% axis([-12 12 -12 12])
grid on
g = gca;
g.XAxisLocation = 'origin';
g.YAxisLocation = 'origin';
g.Box = 'off';
for i=1:neuronas
wlocal = W0(i,:);
b1 = b(i);
syms p1l p2l
eq = wlocal * [p1l;p2l] + b1 == 0;
val = solve(eq,p1l);
p2l = 10;
p1l = subs(val);
% p1l = p(:,1+(i-1)*2)
% p2l = p(:,(i)*2)
fimplicit(@(p1l,p2l) wlocal(1,1)*p1l + wlocal(1,2)*p2l + b1,[-100,100],colores(mod(i,4)+1))
quiver(p1l,p2l,wlocal(1,1),wlocal(1,2),0, 'MaxHeadSize',0.5,"Color",colores(mod(i,4)+1),'DisplayName','_'+ string(i)+'w')
end
legend('FontSize',5,'Location','bestoutside','NumColumns',1)
% [fil,col] = size(W);
for i=1:neuronas
for j=1:2
figure
plot(W(1,i:r:end),'o', 'MarkerSize',10)
title('convergencia del peso '+string(j)+ ' de la neurona '+ string(i) )
% axis([0 length(W(1,i:r:end)) min(W(1,i:r:end)) max(W(1,i:r:end))])
grid on
g = gca;
g.XAxisLocation = 'origin';
g.YAxisLocation = 'origin';
g.Box = 'off';
% [f,c]=size(W(1,i:r:end));
% text(W(1,i:r:end)+0.06*([0:c-1]),W(1,i:r:end)+0.1,string([0:c-1]))
end
end
% [fil,col] = size(W);
for i=1:neuronas
figure
plot(b(1,:),'o', 'MarkerSize',10)
title('convergencia del bias '+string(i))
% axis([0 length(W(1,i:r:end)) min(W(1,i:r:end)) max(W(1,i:r:end))])
grid on
g = gca;
g.XAxisLocation = 'origin';
g.YAxisLocation = 'origin';
g.Box = 'off';
% [f,c]=size(W(1,i:r:end));
% text(W(1,i:r:end)+0.06*([0:c-1]),W(1,i:r:end)+0.1,string([0:c-1]))
end
end